package com.ruoyi.project.dict.jieshi.service.impl;

import com.ruoyi.common.utils.CacheUtil;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.TableSplitUtil;
import com.ruoyi.common.utils.text.Convert;
import com.ruoyi.framework.aspectj.lang.annotation.DataSource;
import com.ruoyi.framework.aspectj.lang.enums.DataSourceType;
import com.ruoyi.project.dict.jieshi.domain.CiJieshi;
import com.ruoyi.project.dict.jieshi.mapper.CiJieshiMapper;
import com.ruoyi.project.dict.jieshi.service.ICiJieshiService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * 词语解释(用户)Service业务层处理
 *
 * @author shixiangwen
 * @date 2020-10-20
 */
@Service
@DataSource(DataSourceType.DICT)
public class CiJieshiServiceImpl implements ICiJieshiService {

    @Autowired
    private CiJieshiMapper ciJieshiMapper;

    /**
     * 查询词语解释(用户)
     *
     * @param id 词语解释(用户)ID
     * @return 词语解释(用户)
     */
    @Override
    public CiJieshi selectCiJieshiById(Long id) {

        int index = (int) (id / 10000000);
        long ciJieshiID = id - 10000000 * index;
        String table = "ci_jieshi_" + index;
        CiJieshi ciJieshi = ciJieshiMapper.selectCiJieshiById(ciJieshiID, table);
        ciJieshi.setId(id);
        return ciJieshi;
    }

    /**
     * 查询词语解释(用户)列表
     *
     * @param ciJieshi 词语解释(用户)
     * @return 词语解释(用户)
     */
    @Override
    public List<CiJieshi> selectCiJieshiList(CiJieshi ciJieshi) {
        if (!StringUtils.isEmpty(ciJieshi.getCi())) {
            String table = TableSplitUtil.getCiJieshiTable(ciJieshi.getCi());
            ciJieshi.setTable(table);
            List<CiJieshi> list = ciJieshiMapper.selectCiJieshiList(ciJieshi);
            for (CiJieshi jieshi : list) {
                long index = TableSplitUtil.getHashCode(jieshi.getCi()) % 10;
                jieshi.setId(10000000 * index + jieshi.getId());
            }
            return list;
        } else {
            return new ArrayList<CiJieshi>();
        }
    }

    /**
     * 新增词语解释(用户)
     *
     * @param ciJieshi 词语解释(用户)
     * @return 结果
     */
    @Override
    public int insertCiJieshi(CiJieshi ciJieshi) {
        return ciJieshiMapper.insertCiJieshi(ciJieshi);
    }

    /**
     * 修改词语解释(用户)
     *
     * @param ciJieshi 词语解释(用户)
     * @return 结果
     */

    @Override
    public int updateCiJieshi(CiJieshi ciJieshi) {

        int index = (int) (ciJieshi.getId() / 10000000);
        long id = ciJieshi.getId() - 10000000 * index;
        String table = "ci_jieshi_" + index;
        CiJieshi old = ciJieshiMapper.selectCiJieshiById(id, table);

        deleteCiJieshiById(ciJieshi.getId());

        CiJieshi newCiJieshi = new CiJieshi();
        newCiJieshi.setCi(ciJieshi.getCi());
        newCiJieshi.setContent(ciJieshi.getContent());
        newCiJieshi.setKkid(old.getKkid());
        newCiJieshi.setCreatedTime(old.getCreatedTime());
        newCiJieshi.setTable(TableSplitUtil.getCiJieshiTable(ciJieshi.getCi()));
        return this.insertCiJieshi(newCiJieshi);
    }

    /**
     * 删除词语解释(用户)对象
     *
     * @param ids 需要删除的数据ID
     * @return 结果
     */
    @Override
    public int deleteCiJieshiByIds(String ids) {
        String[] arrs = Convert.toStrArray(ids);
        int count = 0;
        for (String arr : arrs) {
            count += this.deleteCiJieshiById(Long.parseLong(arr));
        }
        return count;
    }

    /**
     * 删除词语解释(用户)信息
     *
     * @param id 词语解释(用户)ID
     * @return 结果
     */
    @Override
    public int deleteCiJieshiById(Long id) {

        int index = (int) (id / 10000000);
        long ciJieshiID = id - 10000000 * index;
        String table = "ci_jieshi_" + index;
        int ret = ciJieshiMapper.deleteCiJieshiById(ciJieshiID, table);
        if (ret > 0) {
            CacheUtil.deleteCiJieshi(index, ciJieshiID);
        }
        return ret;
    }
}
